home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / kms20src.lha / KMSC / user.c < prev    next >
C/C++ Source or Header  |  1995-04-06  |  27KB  |  1,046 lines
  1. /**********************************
  2.  *              KMS               *
  3.  **********************************
  4.  *  ©1995 by BlackMagic Software  *
  5.  **********************************
  6.  *                                *
  7.  **********************************/
  8.  
  9. #include <KMS/KMS.h>
  10. #include <KMS/KMS_devlib.h>
  11.  
  12. Prototype VOID InitUser(struct Userdaten *);
  13. Prototype struct UserNode *UserCheck(STRPTR);
  14. Prototype struct UserNode *InsertUser(VOID);
  15. Prototype VOID DeleteUser(struct UserNode *);
  16. Prototype BOOL RemoveUser(STRPTR);
  17. Prototype BOOL EditUser(STRPTR);
  18. Prototype BOOL EditUserInfo(struct UserNode *, UWORD);
  19. Prototype BOOL ListUsers(STRPTR);
  20. Prototype ULONG SetAccessBits(ULONG, UWORD);
  21. Prototype VOID GlobalUserEdit(VOID);
  22. Prototype VOID ConvertSpace(STRPTR);
  23. Prototype VOID Upper(STRPTR);
  24. Prototype BOOL CreateUserDir(struct UserNode *);
  25. Prototype VOID TakeUSem(BOOL);
  26. Prototype VOID DropUSem(VOID);
  27. Prototype BOOL AddUMSUser(struct UserNode *);
  28. Prototype BOOL DelUMSUser(struct UserNode *);
  29.  
  30. /*****************************
  31.  * Externe Globale Variablen *
  32.  *****************************/
  33.  
  34. extern struct KMSBase *KMSBase;
  35. extern struct LocalConfig *KMS_LC;
  36.  
  37. extern STRPTR PPArg;
  38.  
  39. extern UBYTE ShutDown, Plop;
  40.  
  41. extern UMSAccount SysUMSAccount;
  42.  
  43. extern struct UserNode DummyUser;
  44.  
  45. /*********************
  46.  * Globale Variablen *
  47.  *********************/
  48.  
  49. /*********************************
  50.  * Neue Userstruktur vorbereiten *
  51.  *********************************
  52.  * I: struct Userdaten *         *
  53.  * O: ---                        *
  54.  *********************************/
  55.  
  56. /// "InitUser"
  57.  
  58. VOID InitUser(struct Userdaten *user)
  59.    {
  60.    struct UserNode *defuser;
  61.  
  62.    clrmem(user, sizeof(struct Userdaten));
  63.  
  64.    defuser = UserCheck("Default");
  65.    if (defuser)
  66.       *user = defuser->UserData;
  67.    else
  68.       {
  69.       user->Level = 10;
  70.       user->CharSet = 0;
  71.       user->Flags = UF_EMU_ANSI|UF_EDIT_INSERT|UF_RMODE_NEW|UF_SCREEN_ED|UF_AUTO_LIST|UF_AUTO_AREALIST|UF_PDAT_SECRET;
  72.       strcpy(user->Prompt, "[%p]> ");
  73.       user->PageLen = 25;
  74.       user->LineLen = 80;
  75.       user->Quota = 10;
  76.       }
  77.    *user->Name = '\0';
  78.    *user->RealName = '\0';
  79.    }
  80.  
  81. ///
  82.  
  83. /**********************************
  84.  * Username auf Gültigkeit prüfen *
  85.  **********************************
  86.  * I: Name                        *
  87.  * O: struct UserNode *           *
  88.  **********************************/
  89.  
  90. /// "UserCheck"
  91.  
  92. struct UserNode *UserCheck(STRPTR name)
  93.    {
  94.    struct UserNode *upoint;
  95.  
  96.    if (!name || !strlen(name))
  97.       return NULL;
  98.  
  99.    ConvertSpace(name);
  100.  
  101.    TakeUSem(FALSE);
  102.    upoint = (struct UserNode *)KMSBase->UserList.mlh_Head;
  103.    while (upoint->Node.mln_Succ)
  104.       {
  105.       if (!stricmp(name, upoint->UserData.Name))
  106.          {
  107.          DropUSem();
  108.          return upoint;
  109.          }
  110.  
  111.       upoint = upoint->Node.mln_Succ;
  112.       }
  113.  
  114.    DropUSem();
  115.  
  116.    return NULL;
  117.    }
  118.  
  119. ///
  120.  
  121. /********************************
  122.  * User neu anlegen             *
  123.  ********************************
  124.  * I: ---                       *
  125.  * O: struct UserNode *         *
  126.  ********************************/
  127.  
  128. /// "InsertUser"
  129.  
  130. struct UserNode *InsertUser(VOID)
  131.    {
  132.    struct UserNode *upoint, *newupoint;
  133.    UWORD id, maxid;
  134.  
  135.    upoint = (struct UserNode *)KMSBase->UserList.mlh_TailPred;
  136.    if (!upoint->Node.mln_Pred)
  137.       {
  138.       SystemError("InsertUser", "No UserList!");
  139.       return NULL;
  140.       }
  141.  
  142.    maxid = 0; id = 0;
  143.    upoint = (struct UserNode *)KMSBase->UserList.mlh_Head;
  144.    while (upoint->Node.mln_Succ)
  145.       {
  146.       id = upoint->UserData.ID;
  147.       if (id > maxid)
  148.          maxid = id;
  149.  
  150.       upoint = (struct UserNode *)upoint->Node.mln_Succ;
  151.       }
  152.  
  153.    maxid++;
  154.    if (maxid == 0) /* Überlauf */
  155.       {
  156.       SystemError("InsertUser", "Too many users!");
  157.       return NULL;
  158.       }
  159.  
  160.    if (!(newupoint = (struct UserNode *)AllocMem((ULONG)sizeof(struct UserNode), MEMF_PUBLIC|MEMF_CLEAR)))
  161.       {
  162.       SystemError("InsertUser", "Out of memory!");
  163.       return NULL;
  164.       }
  165.  
  166.    newupoint->UserData.ID = maxid;
  167.  
  168.    AddTail((struct List *)&KMSBase->UserList, (struct Node *)newupoint);
  169.  
  170.    return newupoint;
  171.    }
  172.  
  173. ///
  174.  
  175. /********************************
  176.  * Userstruktur löschen         *
  177.  ********************************
  178.  * I: struct UserNode *         *
  179.  * O: ---                       *
  180.  ********************************/
  181.  
  182. /// "DeleteUser"
  183.  
  184. VOID DeleteUser(struct UserNode *target)
  185.    {
  186.    if (!target)
  187.       return;
  188.  
  189.    Remove((struct Node *)target);
  190.  
  191.    FreeMem(target, (ULONG)sizeof(struct UserNode));
  192.    }
  193.  
  194. ///
  195.  
  196. /********************************
  197.  * User löschen                 *
  198.  ********************************
  199.  * I: STRPTR name               *
  200.  * O: BOOL Erfolg ja/nein       *
  201.  ********************************/
  202.  
  203. /// "RemoveUser"
  204.  
  205. BOOL RemoveUser(STRPTR name)
  206.    {
  207.    TEXT buff[LEN_DOSPATH+LEN_USERNAME+18+1];
  208.    TEXT buffer[LEN_DOSPATH+1];
  209.    struct UserNode *upoint;
  210.  
  211.    if (!name || !strlen(name))
  212.       return FALSE;
  213.  
  214.    if (upoint = UserCheck(name))
  215.       {
  216.       /* Wenn User momentan online, nicht löschen */
  217.  
  218.       TakeMSem(FALSE);
  219.  
  220.       struct KMSNode *member = KMSBase->MemberList.mlh_Head;
  221.       while (member->Node.mln_Succ)
  222.          {
  223.          if (member->LCPtr->Session.CurrentUser == upoint)
  224.             {
  225.             DropMSem();
  226.             SysMsg(USER_ONLINE);
  227.             return FALSE;
  228.             }
  229.          member = member->Node.mln_Succ;
  230.          }
  231.  
  232.       DropMSem();
  233.  
  234.       /* Löschen */
  235.  
  236.       if (YNRequest(DELETE_USER, FALSE))
  237.          {
  238.          /* User-Directory loeschen */
  239.  
  240.          strcpy(buffer, KMSBase->UserDir);
  241.          strcat(buffer, upoint->UserData.Name);
  242.          ConvertSpace(buffer);
  243.  
  244.          sprintf(buff, "Delete >NIL: %s/#?", buffer);
  245.          SystemCall(buff);
  246.  
  247.          if (!DeleteFile(buffer))
  248.             SystemError("DeleteUser", "Error deleting user dir");
  249.  
  250.          TakeUSem(TRUE);
  251.  
  252.          if (!DelUMSUser(upoint))
  253.             SystemError("DeleteUser", "Error deleting UMS-User");
  254.  
  255.          DeleteUser(upoint);
  256.  
  257.          DropUSem();
  258.  
  259.          return TRUE;
  260.          }
  261.       else
  262.          return FALSE;
  263.       }
  264.    else
  265.       {
  266.       SysMsg(USER_NOT_FOUND);
  267.       return FALSE;
  268.       }
  269.    }
  270.  
  271. ///
  272.  
  273. /********************************
  274.  * User editieren/anlegen       *
  275.  ********************************
  276.  * I: STRPTR name               *
  277.  * O: BOOL Erfolg ja/nein       *
  278.  ********************************/
  279.  
  280. /// "EditUser"
  281.  
  282. BOOL EditUser(STRPTR name)
  283.    {
  284.    struct UserNode *ulock;
  285.  
  286.    if (name)
  287.       ConvertSpace(name);
  288.  
  289.    if (name && stricmp(name, KMS_LC->Session.CurrentUser->UserData.Name))
  290.       {
  291.       /* Angegebenen User editieren bzw. neu anlegen */
  292.  
  293.       if (ulock = UserCheck(name))
  294.          {
  295.          /* Editieren */
  296.  
  297.          SysMsg(EDIT_OLD_USER);
  298.  
  299.          if (!EditUserInfo(ulock, 0))
  300.             return FALSE;
  301.          else
  302.             return TRUE;
  303.          }
  304.       else
  305.          {
  306.          /* Neu anlegen */
  307.  
  308.          TakeUSem(TRUE);
  309.          if (ulock = InsertUser())
  310.             {
  311.             DropUSem();
  312.  
  313.             SysMsg(EDIT_NEW_USER);
  314.  
  315.             InitUser(&ulock->UserData);
  316.             strncpy(ulock->UserData.Name, name, sizeof(ulock->UserData.Name) - 1);
  317.  
  318.             if (!EditUserInfo(ulock, EU_NEW))
  319.                {
  320.                DeleteUser(ulock);
  321.                return FALSE;
  322.                }
  323.  
  324.             /* UMS-User kreieren */
  325.  
  326.             if (!AddUMSUser(ulock))
  327.                {
  328.                SystemError("EditUser", "Error creating UMS-User");
  329.  
  330.                DeleteUser(ulock);
  331.  
  332.                return FALSE;
  333.                }
  334.  
  335.             /* User-Directory anlegen */
  336.  
  337.             if (!CreateUserDir(ulock))
  338.                {
  339.                SystemError("EditUser", "Error creating user dir");
  340.  
  341.                DelUMSUser(ulock);
  342.  
  343.                DeleteUser(ulock);
  344.  
  345.                return FALSE;
  346.                }
  347.  
  348.             return TRUE;
  349.             }
  350.          else
  351.             {
  352.             DropUSem();
  353.             SysMsg(USERLIMIT_EXCEEDED);
  354.             return FALSE;
  355.             }
  356.          }
  357.       }
  358.    else
  359.       {
  360.       if ((ulock = KMS_LC->Session.CurrentUser) == &DummyUser)
  361.          {
  362.          SystemError("EditUser", "No CurrentUser!");
  363.          return FALSE;
  364.          }
  365.  
  366.       /* Aktuellen User editieren */
  367.  
  368.       SysMsg(EDIT_CURR_USER);
  369.  
  370.       EditUserInfo(ulock, 0);
  371.       KMS_LC->Session.CurrentAccess = CheckAccess(KMS_LC->Session.CurrentArea);
  372.       return TRUE;
  373.       }
  374.    }
  375.  
  376. ///
  377.  
  378. /********************************
  379.  * User-Info editieren          *
  380.  ********************************
  381.  * I: struct Userdaten *, Flag  *
  382.  * O: FALSE: Timeout/ShutDown   *
  383.  ********************************/
  384.  
  385. /// "EditUserInfo"
  386.  
  387. BOOL EditUserInfo(struct UserNode *target, UWORD flag)
  388.    {
  389.    LONG result;
  390.    TEXT tmp[LEN_NUMBER+1];
  391.    TEXT pw[LEN_PASSWORD+1];
  392.    TEXT def[2];
  393.    BOOL currentuser = FALSE;
  394.    struct Userdaten user;
  395.  
  396.    user = target->UserData;
  397.  
  398.    if (!strcmp(user.Name, KMS_LC->Session.CurrentUser->UserData.Name))
  399.       currentuser = TRUE;
  400.  
  401.    if (!(flag & EU_PREFS))
  402.       {
  403.       if (!(flag & EU_PWD))
  404.          {
  405.          CmdInput(NULL, PROMPT_UNAME, NULL, user.Name, sizeof(user.Name)-1, INF_PROMPT|INF_NOEMPTY|INF_DEFBUF);
  406.          if (Plop || ShutDown)
  407.             return FALSE;
  408.          strcpy(user.Name, KMS_LC->Session.InputBuffer);
  409.          ConvertSpace(user.Name);
  410.  
  411.          CmdInput(NULL, PROMPT_UREALNAME, NULL, user.RealName, sizeof(user.RealName)-1, INF_PROMPT|INF_NOEMPTY|INF_DEFBUF);
  412.          if (Plop || ShutDown)
  413.             return FALSE;
  414.          strcpy(user.RealName, KMS_LC->Session.InputBuffer);
  415.          }
  416.  
  417.       CmdInput(NULL, PROMPT_UPWD, NULL, NULL, LEN_PASSWORD, INF_PROMPT|INF_HIDE);
  418.       if (Plop || ShutDown)
  419.          return FALSE;
  420.       if (strlen(KMS_LC->Session.InputBuffer))
  421.          {
  422.          strcpy(pw, KMS_LC->Session.InputBuffer);
  423.          CmdInput(NULL, PROMPT_UPWD_REPEAT, NULL, NULL, LEN_PASSWORD, INF_PROMPT|INF_HIDE);
  424.          if (Plop || ShutDown)
  425.             return FALSE;
  426.          if (!strcmp(pw, KMS_LC->Session.InputBuffer))
  427.             {
  428.             if (!strcmp(pw, " "))
  429.                *pw = '\0';
  430.  
  431.             /* Neues Paßwort in ums.config festhalten */
  432.  
  433.             WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgUser, user.RealName,
  434.                                               UMSTAG_CfgName, "PASSWORD",
  435.                                               UMSTAG_CfgData, pw,
  436.                                               TAG_DONE);
  437.             if (currentuser)
  438.                strcpy(KMS_LC->Session.Password, pw);
  439.             }
  440.          else
  441.             SysMsg(PWD_NOT_CHANGED);
  442.          }
  443.  
  444.       if (!(flag & EU_PWD))
  445.          {
  446.          CmdInput(NULL, PROMPT_USTREET, NULL, user.Street, sizeof(user.Street)-1, INF_PROMPT|INF_NOEMPTY|INF_DEFBUF);
  447.          if (Plop || ShutDown)
  448.             return FALSE;
  449.          strcpy(user.Street, KMS_LC->Session.InputBuffer);
  450.  
  451.          CmdInput(NULL, PROMPT_UCITY, NULL, user.City, sizeof(user.City)-1, INF_PROMPT|INF_NOEMPTY|INF_DEFBUF);
  452.          if (Plop || ShutDown)
  453.             return FALSE;
  454.          strcpy(user.City, KMS_LC->Session.InputBuffer);
  455.  
  456.          CmdInput(NULL, PROMPT_UPHONE, NULL, user.Phone, sizeof(user.Phone)-1, INF_PROMPT|INF_NOEMPTY|INF_DEFBUF);
  457.          if (Plop || ShutDown)
  458.             return FALSE;
  459.          strcpy(user.Phone, KMS_LC->Session.InputBuffer);
  460.  
  461.          sprintf(tmp, "%d", user.Level);
  462.          result = CmdInput(NULL, PROMPT_ULEVEL, NULL, tmp, 3, INF_PROMPT|INF_NUMERIC);
  463.          if (Plop || ShutDown)
  464.             return FALSE;
  465.          user.Level = (UWORD)result;
  466.  
  467.          user.AccessBits = SetAccessBits(user.AccessBits, PROMPT_UBITS);
  468.          if (Plop || ShutDown)
  469.             return FALSE;
  470.          }
  471.       }
  472.  
  473.    if (!(flag & EU_PWD))
  474.       {
  475.       sprintf(tmp, "%d", user.CharSet);
  476.       result = CmdInput(NULL, PROMPT_UCHARSET, "0123456789", tmp, 1, INF_PROMPT|INF_NUMERIC);
  477.       if (Plop || ShutDown)
  478.          return FALSE;
  479.       user.CharSet = (UWORD)result;
  480.  
  481.       if (user.Flags & UF_EMU_ANSI)
  482.          strcpy(def, KMSBase->Yes);
  483.       else
  484.          strcpy(def, KMSBase->No);
  485.       CmdInput(NULL, PROMPT_UANSI, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  486.       if (Plop || ShutDown)
  487.          return FALSE;
  488.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  489.          user.Flags |= UF_EMU_ANSI;
  490.       else
  491.          user.Flags &= ~UF_EMU_ANSI;
  492.  
  493.       if (user.Flags & UF_CLS)
  494.          strcpy(def, KMSBase->Yes);
  495.       else
  496.          strcpy(def, KMSBase->No);
  497.       CmdInput(NULL, PROMPT_UCLS, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  498.       if (Plop || ShutDown)
  499.          return FALSE;
  500.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  501.          user.Flags |= UF_CLS;
  502.       else
  503.          user.Flags &= ~UF_CLS;
  504.  
  505.       if (user.Flags & UF_HEAD_LONG)
  506.          strcpy(def, KMSBase->Yes);
  507.       else
  508.          strcpy(def, KMSBase->No);
  509.       CmdInput(NULL, PROMPT_UHLONG, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  510.       if (Plop || ShutDown)
  511.          return FALSE;
  512.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  513.          user.Flags |= UF_HEAD_LONG;
  514.       else
  515.          user.Flags &= ~UF_HEAD_LONG;
  516.  
  517.       if (user.Flags & UF_EDIT_INSERT)
  518.          strcpy(def, KMSBase->Yes);
  519.       else
  520.          strcpy(def, KMSBase->No);
  521.       CmdInput(NULL, PROMPT_UEDITINS, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  522.       if (Plop || ShutDown)
  523.          return FALSE;
  524.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  525.          user.Flags |= UF_EDIT_INSERT;
  526.       else
  527.          user.Flags &= ~UF_EDIT_INSERT;
  528.  
  529.       if (user.Flags & UF_AUTO_LIST)
  530.          strcpy(def, KMSBase->Yes);
  531.       else
  532.          strcpy(def, KMSBase->No);
  533.       CmdInput(NULL, PROMPT_UAUTOLIST, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  534.       if (Plop || ShutDown)
  535.          return FALSE;
  536.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  537.          user.Flags |= UF_AUTO_LIST;
  538.       else
  539.          user.Flags &= ~UF_AUTO_LIST;
  540.  
  541.       if (user.Flags & UF_AUTO_AREALIST)
  542.          strcpy(def, KMSBase->Yes);
  543.       else
  544.          strcpy(def, KMSBase->No);
  545.       CmdInput(NULL, PROMPT_UAUTOAREALIST, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  546.       if (Plop || ShutDown)
  547.          return FALSE;
  548.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  549.          user.Flags |= UF_AUTO_AREALIST;
  550.       else
  551.          user.Flags &= ~UF_AUTO_AREALIST;
  552.  
  553.       if (user.Flags & UF_PDAT_SECRET)
  554.          strcpy(def, KMSBase->Yes);
  555.       else
  556.          strcpy(def, KMSBase->No);
  557.       CmdInput(NULL, PROMPT_PDATSECRET, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  558.       if (Plop || ShutDown)
  559.          return FALSE;
  560.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  561.          user.Flags |= UF_PDAT_SECRET;
  562.       else
  563.          user.Flags &= ~UF_PDAT_SECRET;
  564.  
  565.       result = 1;
  566.       if (user.Flags & UF_RMODE_NEW)
  567.          result = 2;
  568.       else if (user.Flags & UF_RMODE_SEL)
  569.          result = 3;
  570.       else if (user.Flags & UF_RMODE_THRD)
  571.          result = 4;
  572.       sprintf(tmp, "%d", result);
  573.       result = CmdInput(NULL, PROMPT_URMODE, NULL, tmp, 1, INF_PROMPT|INF_NUMERIC);
  574.       if (Plop || ShutDown)
  575.          return FALSE;
  576.       user.Flags &= ~(UF_RMODE_NEW|UF_RMODE_SEL|UF_RMODE_THRD);
  577.       if (result == 2)
  578.          user.Flags |= UF_RMODE_NEW;
  579.       else if (result == 3)
  580.          user.Flags |= UF_RMODE_SEL;
  581.       else if (result == 4)
  582.          user.Flags |= UF_RMODE_THRD;
  583.  
  584.       if (user.Flags & UF_SCREEN_ED)
  585.          strcpy(def, KMSBase->Yes);
  586.       else
  587.          strcpy(def, KMSBase->No);
  588.       CmdInput(NULL, PROMPT_USCREENED, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  589.       if (Plop || ShutDown)
  590.          return FALSE;
  591.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  592.          user.Flags |= UF_SCREEN_ED;
  593.       else
  594.          user.Flags &= ~UF_SCREEN_ED;
  595.  
  596.       CmdInput(NULL, PROMPT_UPROMPT, NULL, user.Prompt, sizeof(user.Prompt)-1, INF_PROMPT|INF_NOEMPTY|INF_DEFBUF);
  597.       if (Plop || ShutDown)
  598.          return FALSE;
  599.       strcpy(user.Prompt, KMS_LC->Session.InputBuffer);
  600.  
  601.       if (!(flag & EU_PREFS))
  602.          {
  603.          sprintf(tmp, "%d", user.Quota);
  604.          result = CmdInput(NULL, PROMPT_UQUOTA, NULL, tmp, 3, INF_PROMPT|INF_NUMERIC);
  605.          if (Plop || ShutDown)
  606.             return FALSE;
  607.          user.Quota = (UWORD)result;
  608.          }
  609.  
  610.       sprintf(tmp, "%d", user.PageLen);
  611.       result = CmdInput(NULL, PROMPT_UPAGELEN, NULL, tmp, 3, INF_PROMPT|INF_NUMERIC);
  612.       if (Plop || ShutDown)
  613.          return FALSE;
  614.       if (result > 9 && result < 256)
  615.          user.PageLen = (UBYTE)result;
  616.  
  617.       sprintf(tmp, "%d", user.LineLen);
  618.       result = CmdInput(NULL, PROMPT_ULINELEN, NULL, tmp, 3, INF_PROMPT|INF_NUMERIC);
  619.       if (Plop || ShutDown)
  620.          return FALSE;
  621.       if (result <= LEN_MAXLINE && result > 39)
  622.          user.LineLen = (UBYTE)result;
  623.  
  624.       CmdInput(NULL, PROMPT_UPROT, KMSBase->YNText, KMSBase->No, 1, INF_PROMPT|INF_UPCASE);
  625.       if (Plop || ShutDown)
  626.          return FALSE;
  627.       if (*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  628.          ProtSelect(FALSE);
  629.       }
  630.  
  631.    Forbid();
  632.    target->UserData = user;
  633.    Permit();
  634.  
  635.    return TRUE;
  636.    }
  637.  
  638. ///
  639.  
  640. /********************************
  641.  * Userliste                    *
  642.  ********************************
  643.  * I: ---                       *
  644.  * O: OK/Fehler                 *
  645.  ********************************/
  646.  
  647. /// "ListUsers"
  648.  
  649. BOOL ListUsers(STRPTR name)
  650.    {
  651.    TEXT timebuff[LEN_MAKETIME+1];
  652.    TEXT buff[LEN_MAKETIME+57+1];
  653.    struct UserNode *upoint;
  654.    UWORD id = 0;
  655.    UBYTE abbruch = 0;
  656.  
  657.    SysMsg(USERLST_HEAD);
  658.    
  659.    ConvertSpace(name);
  660.  
  661.    KMS_LC->Session.LineCounter = 6;
  662.  
  663.    TakeUSem(FALSE);
  664.  
  665.    upoint = (struct UserNode *)KMSBase->UserList.mlh_Head;
  666.    while (upoint->Node.mln_Succ && !abbruch)
  667.       {
  668.       if (stricmp(upoint->UserData.Name, "Default"))
  669.          {
  670.          id++;
  671.  
  672.          if (!name || !stricmp(upoint->UserData.Name, name))
  673.             {
  674.             if (upoint->UserData.LastCall)
  675.                MakeTime(timebuff, 0, upoint->UserData.LastCall);
  676.             else
  677.                strcpy(timebuff, "--------/--------");
  678.  
  679.             if (upoint->UserData.Flags & UF_PDAT_SECRET)
  680.                sprintf(buff, "%4d %-25.25s\n", id, upoint->UserData.Name);
  681.             else
  682.                sprintf(buff, "%4d %-25.25s %-25.25s %s\n", id, upoint->UserData.Name, upoint->UserData.City, timebuff);
  683.  
  684.             abbruch = MsgPrint(buff, 0);
  685.             }
  686.          }
  687.  
  688.       upoint = upoint->Node.mln_Succ;
  689.       }
  690.  
  691.    DropUSem();
  692.  
  693.    return TRUE;
  694.    }
  695.  
  696. ///
  697.  
  698. /****************************************
  699.  * Zugriffsbits setzen                  *
  700.  ****************************************
  701.  * I: Alter AccessBits-Wert, Prompt-Nr. *
  702.  * O: Neuer AccessBits-Wert             *
  703.  ****************************************/
  704.  
  705. /// "SetAccessBits"
  706.  
  707. ULONG SetAccessBits(ULONG accbits, UWORD prompt)
  708.    {
  709.    TEXT accstring[32*LEN_ACCBITNAME+32+1];
  710.    TEXT bitbuff[LEN_NUMBER+1];
  711.    STRPTR arg;
  712.    ULONG acc;
  713.    UBYTE n;
  714.    BOOL repeat = TRUE;
  715.    while (repeat)
  716.       {
  717.       repeat = FALSE;
  718.  
  719.       *accstring = '\0';
  720.       acc = accbits;
  721.       n = 0;
  722.  
  723.       while (acc)
  724.          {
  725.          if (acc & 1)
  726.             {
  727.             if (strlen(KMSBase->AccBitNames[n]))
  728.                strcat(accstring, KMSBase->AccBitNames[n]);
  729.             else
  730.                {
  731.                sprintf(bitbuff, "%d", n+1);
  732.                strcat(accstring, bitbuff);
  733.                }
  734.  
  735.             strcat(accstring, "+");
  736.             }
  737.  
  738.          acc = acc / 2;
  739.          n++;
  740.          }
  741.       if (strlen(accstring))
  742.          accstring[strlen(accstring)-1] = '\0';
  743.  
  744.       CmdInput(NULL, prompt, NULL, accstring, LEN_CMDINPUT, INF_PROMPT|INF_DEFBUF);
  745.       if (Plop || ShutDown)
  746.          return accbits;
  747.  
  748.       acc = 0;
  749.       for(arg = strtok(KMS_LC->Session.InputBuffer, " +"); arg; arg = strtok(NULL, " +"))
  750.          {
  751.          if (atoi(arg))
  752.             {
  753.             if (atoi(arg) < 33)
  754.                acc |= (1L<<(atoi(arg)-1));
  755.             else
  756.                {
  757.                PPArg = arg;
  758.                SysMsg(INVALID_ACCBITNUM);
  759.                PPArg = NULL;
  760.                repeat = TRUE;
  761.                }
  762.             }
  763.          else
  764.             {
  765.             for(n = 0; n < 32; n++)
  766.                {
  767.                if (!stricmp(arg, KMSBase->AccBitNames[n]))
  768.                   {
  769.                   acc |= (1L<<n);
  770.                   break;
  771.                   }
  772.                }
  773.  
  774.             if (n == 32)
  775.                {
  776.                PPArg = arg;
  777.                SysMsg(UNDEFINED_ACCBITNAME);
  778.                PPArg = NULL;
  779.                repeat = TRUE;
  780.                }
  781.             }
  782.          }
  783.  
  784.       accbits = acc;
  785.       }
  786.  
  787.    return accbits;
  788.    }
  789.  
  790. ///
  791.  
  792. /********************************
  793.  * Alle User edieren            *
  794.  ********************************
  795.  * I: ---                       *
  796.  * O: ---                       *
  797.  ********************************/
  798.  
  799. /// "GlobalUserEdit"
  800.  
  801. VOID GlobalUserEdit(VOID)
  802.    {
  803.    TEXT timebuff[LEN_MAKETIME+1];
  804.    TEXT buff[LEN_MAKETIME+57+1];
  805.    struct UserNode *upoint;
  806.    ULONG addbits;
  807.    ULONG delbits;
  808.    UWORD id = 0;
  809.  
  810.    addbits = SetAccessBits(0, PROMPT_UADDBITS);
  811.    if (Plop || ShutDown)
  812.       return;
  813.  
  814.    delbits = SetAccessBits(0, PROMPT_UDELBITS);
  815.    if (Plop || ShutDown)
  816.       return;
  817.  
  818.    if (!addbits && !delbits)
  819.       return;
  820.  
  821.    SysMsg(USERLST_HEAD);
  822.  
  823.    KMS_LC->Session.LineCounter = 6;
  824.  
  825.    TakeUSem(FALSE);
  826.  
  827.    upoint = (struct UserNode *)KMSBase->UserList.mlh_Head;
  828.    while (upoint->Node.mln_Succ)
  829.       {
  830.       id++;
  831.  
  832.       if (upoint->UserData.LastCall)
  833.          {
  834.          MakeTime(timebuff, 0, upoint->UserData.LastCall);
  835.          sprintf(buff, "%4d %-25.25s %-25.25s %s\n", id, upoint->UserData.Name, upoint->UserData.City, timebuff);
  836.          }
  837.       else
  838.          sprintf(buff, "%4d %-25.25s %-25.25s --------/--------\n", id, upoint->UserData.Name, upoint->UserData.City);
  839.  
  840.       MsgPrint(buff, 0);
  841.  
  842.       if (addbits)
  843.          upoint->UserData.AccessBits |= addbits;
  844.       if (delbits)
  845.          upoint->UserData.AccessBits &= ~delbits;
  846.  
  847.       upoint = upoint->Node.mln_Succ;
  848.       }
  849.  
  850.    DropUSem();
  851.    }
  852.  
  853. ///
  854.  
  855. /********************************
  856.  * Leerzeichen -> Underscore    *
  857.  ********************************
  858.  * I: STRPTR                    *
  859.  * O: ---                       *
  860.  ********************************/
  861.  
  862. /// "ConvertSpace"
  863.  
  864. VOID ConvertSpace(STRPTR string)
  865.    {
  866.    if (!string)
  867.       return;
  868.  
  869.    while (*string)
  870.       {
  871.       if (*string == ' ')
  872.          *string = '_';
  873.  
  874.       string++;
  875.       }
  876.    }
  877.  
  878. ///
  879.  
  880. /********************************
  881.  * String -> Großbuchstaben     *
  882.  ********************************
  883.  * I: STRPTR                    *
  884.  * O: ---                       *
  885.  ********************************/
  886.  
  887. /// "Upper"
  888.  
  889. VOID Upper(STRPTR string)
  890.    {
  891.    if (!string)
  892.       return;
  893.  
  894.    while (*string)
  895.       {
  896.       *string = toupper(*string);
  897.       string++;
  898.       }
  899.    }
  900.  
  901. ///
  902.  
  903. /********************************
  904.  * Userdir anlegen              *
  905.  ********************************
  906.  * I: struct UserNode *         *
  907.  * O: OK TRUE/FALSE             *
  908.  ********************************/
  909.  
  910. /// "CreateUserDir"
  911.  
  912. BOOL CreateUserDir(struct UserNode *ulock)
  913.    {
  914.    BPTR lock;
  915.    TEXT buff1[LEN_DOSPATH+1];
  916.    TEXT buff2[LEN_DOSPATH+1];
  917.    TEXT buff3[LEN_MAXLINE+1];
  918.  
  919.    strcpy(buff1, KMSBase->UserDir);
  920.    strcat(buff1, ulock->UserData.Name);
  921.    ConvertSpace(buff1);
  922.  
  923.    if (lock = CreateDir(buff1))
  924.       {
  925.       UnLock(lock);
  926.       
  927.       if (UserCheck("Default"))
  928.          {
  929.          strcpy(buff2, KMSBase->UserDir);
  930.          strcat(buff2, "Default");
  931.          ConvertSpace(buff2);
  932.  
  933.          sprintf(buff3, "Copy >NIL: %s %s", buff2, buff1);
  934.          SystemCall(buff3);
  935.          }
  936.       else
  937.          {
  938.          /* LOGIN.COM kopieren */
  939.  
  940.          sprintf(buff2, "%sLOGIN.COM", KMSBase->UserDir);
  941.          strcat(buff1, "/LOGIN.COM");
  942.  
  943.          Copy(buff2, buff1, FALSE);
  944.          }
  945.  
  946.       return TRUE;
  947.       }
  948.    else
  949.       return FALSE;
  950.    }
  951.  
  952. ///
  953.  
  954. /********************************
  955.  * Usersemaphore reservieren    *
  956.  ********************************
  957.  * I: BOOL exclusive            *
  958.  * O: ---                       *
  959.  ********************************/
  960.  
  961. /// "TakeUSem"
  962.  
  963. VOID TakeUSem(BOOL exclusive)
  964.    {
  965.    if (exclusive)
  966.       ObtainSemaphore(&KMSBase->UserSem);
  967.    else
  968.       ObtainSemaphoreShared(&KMSBase->UserSem);
  969.    }
  970.  
  971. ///
  972.  
  973. /********************************
  974.  * Usersemaphore freigeben      *
  975.  ********************************
  976.  * I: ---                       *
  977.  * O: ---                       *
  978.  ********************************/
  979.  
  980. /// "DropUSem"
  981.  
  982. VOID DropUSem(VOID)
  983.    {
  984.    ReleaseSemaphore(&KMSBase->UserSem);
  985.    }
  986.  
  987. ///
  988.  
  989. /********************************
  990.  * UMS-Usereintrag erzeugen     *
  991.  ********************************
  992.  * I: struct UserNode *         *
  993.  * O: Erfolg TRUE/FALSE         *
  994.  ********************************/
  995.  
  996. /// AddUMSUser
  997.  
  998. BOOL AddUMSUser(struct UserNode *unode)
  999.    {
  1000.    if (!WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgCreateUser, unode->UserData.RealName,
  1001.                                           TAG_DONE))
  1002.       return FALSE;
  1003.  
  1004.    if (WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgUser, unode->UserData.RealName,
  1005.                                          UMSTAG_CfgCreateAlias, unode->UserData.Name,
  1006.                                          TAG_DONE))
  1007.       if (WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgUser, unode->UserData.RealName,
  1008.                                             UMSTAG_CfgName, "READACCESS",
  1009.                                             UMSTAG_CfgData, "#?",
  1010.                                             TAG_DONE))
  1011.          if (WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgUser, unode->UserData.RealName,
  1012.                                                UMSTAG_CfgName, "WRITEACCESS",
  1013.                                                UMSTAG_CfgData, "#?",
  1014.                                                TAG_DONE))
  1015.             if (WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgUser, unode->UserData.RealName,
  1016.                                                   UMSTAG_CfgName, "NETACCESS",
  1017.                                                   UMSTAG_CfgData, "#?",
  1018.                                                   TAG_DONE))
  1019.                return TRUE;
  1020.  
  1021.    WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgDeleteUser, unode->UserData.RealName,
  1022.                                      TAG_DONE);
  1023.  
  1024.    return FALSE;
  1025.    }
  1026.  
  1027. ///
  1028.  
  1029. /********************************
  1030.  * UMS-Usereintrag löschen      *
  1031.  ********************************
  1032.  * I: struct UserNode *         *
  1033.  * O: Erfolg TRUE/FALSE         *
  1034.  ********************************/
  1035.  
  1036. /// DelUMSUser
  1037.  
  1038. BOOL DelUMSUser(struct UserNode *unode)
  1039.    {
  1040.    if (!WriteUMSConfigTags(SysUMSAccount, UMSTAG_CfgDeleteUser, unode->UserData.RealName,
  1041.                                           TAG_DONE))
  1042.       return FALSE;
  1043.    }
  1044.  
  1045. ///
  1046.